/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Calculos;

import java.util.ArrayList;
import org.jfree.chart.ChartPanel;

/**
 *
 * @author Beto
 */
public class CalculaDistribuida {

    private double incremento=0.005;
    private double inicoViga;
    private double RA,RB;
    private double carga,posicao;
    private static final double coeficienteE = 205*Math.pow(10, 9);
    private ArrayList<double []> cargaDistribuida=new ArrayList<double[]>();
     private ArrayList<double []> deformada=new ArrayList<double[]>();


       public CalculaDistribuida(double  inicioViga) {
           this.inicoViga=inicioViga;
    }





private void calculaReacoesApoios(double forcadistribuida,double comprimentocarga,double tamanhoviga,double posicaoInicial){
    ///////////////////Reação para RA///////////////////////
     carga=forcadistribuida*comprimentocarga;//força distribuida * tamanho da carga = peso total da carga
     posicao=((posicaoInicial)+((posicaoInicial)+comprimentocarga))/2;//encontrando  o ponto de aplicação 
    //uma carga concentrada da carga resultante (como se fosse)
    RA=(carga*(tamanhoviga-posicao))/tamanhoviga;


    ///////////////////////Reação para RB/////////////////

    RB=(carga*posicao)/tamanhoviga;
}


    public void CalculaCargaDistribuida(double forcadistribuida,double comprimentocarga,double tamanhoviga,double posicaoInicial){
        double resultados[]=new double[2];
         ////calcula reações nos apoios
        calculaReacoesApoios(forcadistribuida, comprimentocarga, tamanhoviga, posicaoInicial);


        resultados[0]=MomentoFletor(forcadistribuida, comprimentocarga,tamanhoviga,posicaoInicial);
        resultados[1]=EsforcoCortante(forcadistribuida, comprimentocarga,tamanhoviga,posicaoInicial);

      // Graficos Distribuida= new Graficos("Gráfico Carga Distribuida","Momento Fletor", cargaDistribuida);
       
    }

    private double EsforcoCortante(double forcadistribuida,double comprimentocarga,double tamanhoviga,double posicaoInicial){
        calculaFuncaoEsforcoCortante(forcadistribuida, comprimentocarga,tamanhoviga,posicaoInicial);
        return (forcadistribuida*tamanhoviga)/2;
    }



    //calcula o diagrama de Esforço cortante
    private void calculaFuncaoEsforcoCortante(double forcadistribuida, double comprimentocarga, double tamanhoviga, double posicaoInicial) {


        int tamanhoVetor = (int) (tamanhoviga / incremento);
        double y[] = new double[tamanhoVetor];
        double x[] = new double[tamanhoVetor];
        for (int i = 1; i < tamanhoVetor; i++) {
            x[i] = x[i - 1] + incremento;
        }



        for (int i = 0; i < tamanhoVetor; i++) {
            if (x[i] <= (posicaoInicial)) {//primeiro intervalo (x antes do inicio da carga distribuida)
                y[i]=(forcadistribuida*comprimentocarga*(tamanhoviga-posicao))/tamanhoviga;
            }
            //entervalo que contem a carga
            else if ((x[i] >= (posicaoInicial)) && (x[i] <= ((posicaoInicial) + comprimentocarga))) {
                y[i] = RA-(forcadistribuida*(x[i]-(posicaoInicial)));
                  
            } // por fim quando x estiver no intervalo após a carga
            else if ((x[i] >= ((posicaoInicial) + comprimentocarga))) {
                y[i]=(-1*forcadistribuida*comprimentocarga*posicao)/tamanhoviga;
            }
        }




        // new Graficos("Gráfico Esforço Cortante",x, y);// gera o gráfico
        cargaDistribuida.add(x);//adicionando  o vetor com os dados x cortante
        cargaDistribuida.add(y);//vetor com dados y Cortante

    }



    //esse método calcula o momento fletor máximo

    private double MomentoFletor(double forcadistribuida,double comprimentocarga,double tamanhoviga,double posicaoInicial){

        caclucaFuncao(forcadistribuida,comprimentocarga,tamanhoviga,posicaoInicial);//chama  o calculo da função para esboçar o diagrama
        return (forcadistribuida*(Math.pow(comprimentocarga,2)))/8;


}
    
    
    
     //Calcula os pontos para esboçar  o diagrama do momento fletor para uma carga distribuida em qualquer ponto
    private void caclucaFuncao(double forcadistribuida,double comprimentocarga,double tamanhoviga,double posicaoInicial){
        
        int tamanhoVetor=(int) (tamanhoviga / incremento);
        double y[]=new double[tamanhoVetor];
        double x[]=new double[tamanhoVetor];
        for(int i=1;i<tamanhoVetor;i++){
            x[i]=x[i-1]+incremento;
        }

        for(int i=0;i<tamanhoVetor;i++){
                if(x[i]<=(posicaoInicial)){//primeiro intervalo (x antes do inicio da carga distribuida)
                    y[i]=RA*x[i];
                }
                //entervalo que contem a carga
                else if((x[i]>=(posicaoInicial)) && (x[i]<=((posicaoInicial)+comprimentocarga))){
                    y[i]=(RA*x[i])-((forcadistribuida/2)*(Math.pow((x[i]-(posicaoInicial)), 2)));
                }
                    // por fim quando x estiver no intervalo após a carga
                else if((x[i]>=((posicaoInicial)+comprimentocarga))){
                    y[i]=RB*(tamanhoviga-x[i]);
                }
        }

      //  new Graficos("Gráfico Momento Fletor",x, y);// gera o gráfico
        cargaDistribuida.add(x);//adicionando  o vetor com os dados x fletor
        cargaDistribuida.add(y);//vetor com dados y fletor


    }

    public double getRA() {
        return RA;
    }

    public double getRB() {
        return RB;
    }

    public ArrayList<double[]> getCargaDistribuida() {
        return cargaDistribuida;
    }

    public double calculaMomentoFletorNoPonto(double x, double forcadistribuida, double comprimentocarga, double tamanhoviga, double posicaoInicial) {

        double resultado = 0;
        if (x <= (posicaoInicial)) {//primeiro intervalo (x antes do inicio da carga distribuida)
            resultado = RA * x;
        } //entervalo que contem a carga
        else if ((x >= (posicaoInicial)) && (x <= ((posicaoInicial) + comprimentocarga))) {
            resultado = (RA * x) - ((forcadistribuida / 2) * (Math.pow((x - (posicaoInicial)), 2)));
        } // por fim quando x estiver no intervalo após a carga
        else if ((x >= ((posicaoInicial) + comprimentocarga))) {
            resultado = RB * (tamanhoviga - x);
        }

        return resultado;
    }

      public double calculaEsforcoCortanteNoPonto(double x,double forcadistribuida,
              double comprimentocarga, double tamanhoviga, double posicaoInicial) {

              double resultado = 0;

            if (x <= (posicaoInicial)) {//primeiro intervalo (x antes do inicio da carga distribuida)
                resultado=(forcadistribuida*comprimentocarga*(tamanhoviga-posicao))/tamanhoviga;
            }
            //entervalo que contem a carga
            else if ((x >= (posicaoInicial)) && (x <= ((posicaoInicial) + comprimentocarga))) {
                resultado = RA-(forcadistribuida*(x-(posicaoInicial)));

            } // por fim quando x estiver no intervalo após a carga
            else if ((x >= ((posicaoInicial) + comprimentocarga))) {
                resultado=(-1*forcadistribuida*comprimentocarga*posicao)/tamanhoviga;
            }

              return resultado;
        }


      public void CalculaDeformadaVetor(double forcadistribuida, double comprimentocarga, double tamanhoviga, double posicaoInicial, double IY) {

        double temp;
        double RB=(forcadistribuida*comprimentocarga*(posicaoInicial+(posicaoInicial+comprimentocarga)))/tamanhoviga;
        int tamanhoVetor = (int) (tamanhoviga / incremento);
        double y[] = new double[tamanhoVetor];
        double x[] = new double[tamanhoVetor];
        for (int i = 1; i < tamanhoVetor; i++) {
            x[i] = x[i - 1] + incremento;
        }

        for (int i = 0; i < tamanhoVetor; i++) {
            
            y[i]=calculaDeformadaNoPonto(x[i], forcadistribuida, comprimentocarga, tamanhoviga, posicaoInicial, IY);
        }
        deformada.add(x);
        deformada.add(y);


    }

      public double calculaDeformadaNoPonto(double x,double forcadistribuida, double comprimentocarga, double tamanhoviga, double posicaoInicial, double IY) {
      
          double resultado = 0;
          double q = forcadistribuida;
          double a = comprimentocarga;
          double L = tamanhoviga;
          if (x <= comprimentocarga) {
              resultado = x * q * (Math.pow(a, 4) - (4 * Math.pow(a, 3) * L) + (4 * Math.pow(a, 2) * Math.pow(L, 2)) + (2 * Math.pow(a, 2) * Math.pow(x, 2)) - (4 * a * L * Math.pow(x, 2)) + (L * Math.pow(x, 3)));
          } 
          else if (x >= comprimentocarga) {
              resultado = q * Math.pow(a, 2) * ((-1*(Math.pow(a, 2) * L)) + (4 * Math.pow(L, 2) * x) + (Math.pow(a, 2) * x) - (6 * L * Math.pow(x, 2)) + (2 * Math.pow(x, 3)));
          }
          resultado /= 24 * L * IY * coeficienteE;
          return resultado;
      }
      
    public double calculaD(double q, double l, double a, double x) {
        double d = 0;
        d = q * (l - a) * Math.pow(x, 3) / (6 * l) - (q / 24) * (Math.pow(x, 4)
                - 4 * a * Math.pow(x, 3) + 6 * x * x * a * a);//+c1 +c2 só que c1+c2=0
        return d;
    }

 
      public double calculaV(double d, double e, double ix){
          double v = 0;
          v= d/(e*ix);
          return v;
      }

    public ArrayList<double[]> getDeformada() {
        return deformada;
    }

      
}



